sqlc analyze ran ClickHouse and GoogleSQL on the core catalog and analyzer while PostgreSQL, MySQL and SQLite still went through the legacy compiler. This routes all five dialects through the core, and — since a dialect now has to be described rather than coded — moves each engine's type system and standard library out of Go and into data files the core and the legacy compiler both read.

generate, vet and compile are untouched: they still use each engine's own analysis path.

Analyzing every dialect through the core

• compiler: NewCompiler takes options; WithCoreAnalysis, which the analyze command passes, builds a core catalog seeded with the engine's dialect and skips the legacy catalog and the analyzer connection entirely. ClickHouse and GoogleSQL keep doing so unconditionally.
• core: literals take the type each dialect names rather than PostgreSQL's (the analyzer hardcoded int4/numeric/text/bool, which only PostgreSQL has); a type a schema declares — an enum, or one of SQLite's free-form type names — gains the dialect's comparison operators; array types are named after their element.
• core/schema: enums, functions, views, CREATE TABLE AS, ALTER TABLE and the rename statements now load into the catalog, and a column's array-ness is read from either the type name or the column. Five new catalog queries back the ALTER TABLE mutations, generated by sqlc itself.
• core/analyzer: CTEs, set operations, subqueries in FROM and as expressions (including correlated ones), functions in FROM, IN, BETWEEN, CASE, COALESCE, array expressions, casts, and output-name references in GROUP BY/HAVING. Overloads are chosen by argument type, polymorphic return types (max(anyelement)) resolve to the argument's type, and an unknown function or operator leaves the expression untyped instead of failing the whole query.

Dialects as data

A dialect is a directory each engine embeds:

internal/engine/postgresql/dialect/
  dialect.json     what the dialect is called and the rules it is built by
  types.jsonl      the types it defines
  operators.jsonl  overloads beyond the ones the rules generate
  casts.jsonl      casts beyond the ones the rules generate
  functions.jsonl  the functions it ships with
  relations.jsonl  the system tables and views it ships with

The lists are JSONL and are applied a record at a time as they are read, so a function list running to thousands of entries is never held in memory as a whole; dialect.json holds one object, so it is read whole. Unknown fields are rejected, which catches a misspelled key where it is written. Any list may be left out — ClickHouse ships three files, PostgreSQL six.

With a record-per-line format the engines' standard libraries fit in it, so they moved out of Go:

Each list is read once per process and feeds both the analysis core and the catalog the legacy compiler builds, so there is one copy of the data rather than one per consumer. sqlc-pg-gen writes the two PostgreSQL files, so a regeneration reproduces this layout rather than reverting to Go. The binary drops about 3 MB.

Moving the system catalogs across also closed a gap: the core had no notion of a relation it did not read from the user's schema, so a query against information_schema.columns or pg_catalog.pg_class could not be analyzed at all. It can now.

Behavior change

analyze reports type names as the catalog stores them, in lower case — so SQLite's INTEGER is now integer. The analyze_basic/sqlite golden reflects that, and docs/howto/analyze.md calls it out.

Testing

CLAUDE.md now states the testing strategy this follows: new work is covered by end-to-end cases under internal/endtoend/testdata, not by unit tests, and the file describes how a case is laid out. Sixteen analyze cases are added or extended across the five dialects, covering joins, aggregates, CTEs, RETURNING, multi-table DELETE, sqlc.arg/narg/slice, and the PostgreSQL system catalogs.

As a wider check I ran sqlc analyze over every PostgreSQL/MySQL/SQLite schema+query pair in examples/ and internal/endtoend/testdata — 262 pairs, of which 254 pass, up from 178 when the three dialects were first pointed at the core. Roughly twelve of the remaining are intentionally-invalid fixtures (invalid_table_alias, sqlc_arg_invalid, relation_does_not_exist, MySQL files written with $1). The genuine gaps left are recursive CTEs, MySQL schema-qualified column references, SQLite virtual tables and table-valued functions (json_each), unqualified references to system tables that rely on search_path, and one MySQL self-join that references a table by a name it aliased away.

TestReplay, TestParse, TestFormat and TestJsonSchema pass — the generate goldens are what prove the standard-library conversion kept the data intact, since function return types drive codegen. The TestValidSchema failures in my environment are pre-existing: no databases run there, and the count is identical on main.

Left for later

• Seeding PostgreSQL's system catalogs costs about 40 ms per invocation. Loading them on demand fixed that, but the commit is reverted here — a different approach to the cost is planned.
• The ~60 contrib/ extension catalogs are still generated Go; converting them needs a live PostgreSQL with each extension installed.